home *** CD-ROM | disk | FTP | other *** search
/ Shareware Grab Bag / Shareware Grab Bag.iso / 090 / aztcmtsk.arc / AZTASK.TSH < prev   
Text File  |  1986-03-24  |  5KB  |  113 lines
  1. /* ========================================================== */
  2. /*                                  */
  3. /*    TASKING.H -- interface file for Tasking, Queues       */
  4. /*                                  */
  5. /* The Task, Queue, and Event structures are defined here in  */
  6. /* terms of anonymous words.  This "opaque" definition of the */
  7. /* structures allows the client program to declare pointers   */
  8. /* to them, but not to interpret their internal values.  Full */
  9. /* definitions of them appear in TASKING.C. See also TROOT.C, */
  10. /* the version of CROOT modified for tasking.              */
  11. /*                                  */
  12. /* Also defined here are externs for the functions that work  */
  13. /* on these structures, with declarations of their arguments  */
  14. /* for use by compilers that check argument types.          */
  15. /*                                  */
  16. /* Note that any function that takes a Queue will take an     */
  17. /* Event instead, and that an Event is merely a one-item      */
  18. /* Queue.  Thus posting an Event is merely putting one item   */
  19. /* in the event's queue, and waiting on an Event is getting   */
  20. /* from its queue.                          */
  21. /*                                  */
  22. /* Copyright (C) 1986 by David E. Cortesi, 415 Cambridge Ave  */
  23. /* Suite 18, Palo Alto, CA 94306.  Permission to copy and     */
  24. /* redistribute without charge is granted provided only that  */
  25. /* this notice is retained.  Distribution for a fee, whether  */
  26. /* alone or as part of another product and whether or not for */
  27. /* profit, requires explicit permission from the author.      */
  28. /* ========================================================= */
  29.  
  30. struct Queue { unsigned qwords[5]; };
  31. struct Event { unsigned ewords[7]; };
  32. struct Task  { unsigned twords[5]; };
  33.  
  34. /* creates a queue that can hold num words, num at least 1. */
  35. extern struct Queue *qmake(/*num*/) /*int num*/;
  36.  
  37. /* creates an Event (but not a social one) */
  38. extern struct Event *evmake();
  39.  
  40. /* returns oldest item from *adq, waiting if necessary */
  41. extern unsigned qget(/*adq*/) /*struct Queue *adq*/;
  42.  
  43. /* installs val as newest item in *adq, waits if *adq is full */
  44. extern int /* void */ qput(/*adq,val*/)
  45.     /*struct Queue *adq; unsigned val*/;
  46. /* returns 1 if *adq is empty, i.e. if qget(adq) would wait */
  47. extern int qempty(/*adq*/) /*struct Queue *adq*/;
  48.  
  49. /* returns 1 if *adq is not empty (qget(adq) would not wait) */
  50. extern int qnotmt(/*adq*/) /*struct Queue *adq */;
  51.  
  52. /* returns 1 if *adq is full, i.e. if qput(adq) would wait */
  53. extern int qfullQ(/*adq*/) /*struct Queue *adq*/;
  54.  
  55. /* returns 1 if *adq is not full (qput(adq) wouldn't wait */
  56. extern int qnotfull(/*adq*/) /*struct Queue *adq*/;
  57.  
  58. #define evwait(E) qget((E))
  59. #define evpost(E) qput((E),1)
  60. #define posted(E) qnotmt((E))
  61.  
  62. /* creates a task to execute in fun() with a stack of nst words.
  63.    function fun takes nar arguments, which should follow, for
  64.    example, after t = maketask(&doit,256,2,"first",myevent), the
  65.    new task would with a call to doit("first",myevent) */
  66.  
  67. extern struct Task *maketask(/*fun,nst,nar[,others...]*/)
  68.     /*int (*fun)(), nst, nar*/;
  69.  
  70. /* returns the active tasks Task address (for passing to other
  71.    functions so they can sleep you) */
  72.  
  73. extern struct Task *myTask();
  74.  
  75. /* ends the active task (when the last task ends, the program
  76.    ends, and not until) */
  77.  
  78. extern int /*void*/ endtask();
  79.  
  80. /* kills the specified task. */
  81.  
  82. extern int /*void*/ killtask(/*adt*/) /*struct Task *adt*/;
  83.  
  84. /* gives every other task a chance to run before control comes
  85.    back to the current task.  The qget() function does a defer()
  86.    automatically, but qput() does not.    Either qget() or defer()
  87.    must appear in the tightest loop in any task to avoid
  88.    starving other tasks of execution time. */
  89.  
  90. extern int /*void*/ defer();
  91.  
  92. /* puts a task to sleep, preventing it from getting any CPU
  93.    cycles.  requires a twake() to awaken it. */
  94.  
  95. extern int /*void*/ tsleep(/*adt*/) /*struct Task *adt*/;
  96.  
  97. /* wakes up a task sleeping from tsleep() (also wakes up a
  98.    task waiting on a queue, but it will immediately test the
  99.    queue and go to sleep again.) */
  100.  
  101. extern int /*void*/ twaken(/*adt*/) /*struct Task *adt*/;
  102.  
  103. /* returns 1 if the named task is active, i.e. would execute
  104.    on the next defer() call */
  105.  
  106. extern int tactive(/*adt*/) /*struct Task *adt*/;
  107.  
  108. /* returns 0 if the named task is active, 1 if it has been
  109.    put to sleep by tsleep(), another nonzero if it is waiting
  110.    on a qget or qput call. */
  111.  
  112. extern int tinact(/*adt*/) /*struct Task *adt*/;
  113.